/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package model;

import view.JanelaTokens;
import model.Token;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 *
 * @author Anderson
 */
public class TokenAnalyser {

    private int estadoAtual = 0;
    private int estadoAnt = 0;
    private int entrada = 0;
    private int i = 0;
    private String tokenFormation = "";
    private int[][] automato = new int[66][98];
    private String codigo = null;
    private boolean pegarCaractere = true;
    private ArrayList<int[]> dadosArquivo;
    private JanelaTokens janela;
    private List<Token> listaTokens;
    private boolean programaSemErro=true;
    private List<String>palavrasReservadas;

    public TokenAnalyser() {
        listaTokens = new LinkedList<Token>();
        palavrasReservadas = new LinkedList<String>();
        //inicialização das palavras reservadas
        palavrasReservadas.add("programa");
        palavrasReservadas.add("variaveis");
        palavrasReservadas.add("constantes");
        palavrasReservadas.add("registro");
        palavrasReservadas.add("tipo");
        palavrasReservadas.add("funcao");
        palavrasReservadas.add("retorno");
        palavrasReservadas.add("vazio");
        palavrasReservadas.add("principal");
        palavrasReservadas.add("se");
        palavrasReservadas.add("entao");
        palavrasReservadas.add("senao");
        palavrasReservadas.add("enquanto");
        palavrasReservadas.add("para");
        palavrasReservadas.add("leia");
        palavrasReservadas.add("escreva");
        palavrasReservadas.add("inteiro");
        palavrasReservadas.add("real");
        palavrasReservadas.add("logico");
        palavrasReservadas.add("caractere");
        palavrasReservadas.add("cadeia");
        palavrasReservadas.add("verdadeiro");
        palavrasReservadas.add("falso");
    }
    
    public TokenAnalyser(JanelaTokens janela) {
        listaTokens = new LinkedList<Token>();
        //inicialização das palavras reservadas
        palavrasReservadas = new LinkedList<String>();
        palavrasReservadas.add("programa");
        palavrasReservadas.add("variaveis");
        palavrasReservadas.add("constantes");
        palavrasReservadas.add("registro");
        palavrasReservadas.add("tipo");
        palavrasReservadas.add("funcao");
        palavrasReservadas.add("retorno");
        palavrasReservadas.add("vazio");
        palavrasReservadas.add("principal");
        palavrasReservadas.add("se");
        palavrasReservadas.add("entao");
        palavrasReservadas.add("senao");
        palavrasReservadas.add("enquanto");
        palavrasReservadas.add("para");
        palavrasReservadas.add("leia");
        palavrasReservadas.add("escreva");
        palavrasReservadas.add("inteiro");
        palavrasReservadas.add("real");
        palavrasReservadas.add("logico");
        palavrasReservadas.add("caractere");
        palavrasReservadas.add("cadeia");
        palavrasReservadas.add("verdadeiro");
        palavrasReservadas.add("falso");
        this.janela=janela;
    }

    public boolean analyseString(char[] linha)  {
          
        tokenFormation = "";
        entrada = (int)linha[0]; //conversão do caractere para ASCII
        if(entrada!=32 && entrada !=10) //evitando espaço em branco e enters tmb
        tokenFormation += linha[0]; //armazenamento do token

        if (entrada == 10) { //verificação dos caracteres enter, tab, EOF = Ç;
            estadoAtual = automato[estadoAtual][96];
        } else if (entrada == 9) {
            estadoAtual = automato[estadoAtual][97];
        } else if (entrada == 199) {
            estadoAtual = automato[estadoAtual][95];
        } else {

            estadoAtual = automato[estadoAtual][entrada - 32];
        }

        // estadoAtual = automato[estadoAtual][entrada-32];
        System.out.print("\nentrada " + linha[0] + " " + "estadoAnterior: " + estadoAnt + " -> " + estadoAtual);

        switch (estadoAtual) { //Esse é o primeiro switch case e verifica o primeiro carctere;
            // verificar a logica desse switch poteriormente

            case 22: //operador PONTO
                // i--; // identificador maior;
                Token nova2;
                if (tokenFormation.contains(".")) {
                    tokenFormation = "" + tokenFormation.charAt(0);
                    nova2 = new Token(tokenFormation, estadoAtual, "Operador Ponto");
                    janela.preencherTabela(nova2.getToken(),nova2.getTipo());
                    listaTokens.add(nova2);
                    nova2.imprimeToken();
                }
                estadoAtual = 0;
                tokenFormation = "";
                break;

            case 23: //Abre Chaves
                // i--; // identificador maior;
                Token nova3;
                if (tokenFormation.contains("{")) {
                    tokenFormation = "" + tokenFormation.charAt(0);
                    nova3 = new Token(tokenFormation, estadoAtual, "Abre Chaves");
                    janela.preencherTabela(nova3.getToken(),nova3.getTipo());
                    listaTokens.add(nova3);
                    nova3.imprimeToken();
                }
                estadoAtual = 0;
                tokenFormation = "";
                break;

                
                case 29: //Delimitador virgula.
                    Token nova4;
                    tokenFormation += linha[i];
                    //System.out.println("Entrou no case");
                    if (tokenFormation.contains(",")) {
                        tokenFormation = "" + tokenFormation.charAt(0);
                        nova4 = new Token(tokenFormation, estadoAtual, "DELIMITADOR VIRGULA");
                        janela.preencherTabela(nova4.getToken(),nova4.getTipo());
                        listaTokens.add(nova4);
                        nova4.imprimeToken();
                    }
                    estadoAtual = 0;
                    tokenFormation = "";
                    break;

                
            case 24: //Fecha Chaves
                // i--; // identificador maior;
                Token nova5;
                if (tokenFormation.contains("}")) {
                    tokenFormation = ""+ tokenFormation.charAt(0);
                    nova5 = new Token(tokenFormation, estadoAtual, "Fecha Chaves");
                    janela.preencherTabela(nova5.getToken(),nova5.getTipo());
                    listaTokens.add(nova5);
                    nova5.imprimeToken();
                }
                estadoAtual = 0;
                tokenFormation = "";
                break;
                
            case 25: //Abre Colchete
                // i--; // identificador maior;
                Token nova6;
                if (tokenFormation.contains("[")) {
                    tokenFormation = "" + tokenFormation.charAt(0);
                    nova6 = new Token(tokenFormation, estadoAtual, "Abre Colchete");
                    janela.preencherTabela(nova6.getToken(),nova6.getTipo());
                    listaTokens.add(nova6);
                    nova6.imprimeToken();
                }
                estadoAtual = 0;
                tokenFormation = "";
                break;
                
            case 26: //Fecha Colchete
                // i--; // identificador maior;
                Token nova7;
                if (tokenFormation.contains("]")) {
                    tokenFormation = "" + tokenFormation.charAt(0);
                    nova7 = new Token(tokenFormation, estadoAtual, "Fecha Colchete");
                    janela.preencherTabela(nova7.getToken(),nova7.getTipo());
                    listaTokens.add(nova7);
                    nova7.imprimeToken();
                }
                estadoAtual = 0;
                tokenFormation = "";
                break;
                
            case 27: //Abre parêntes
                Token nova8;
                if (tokenFormation.contains("(")) {
                    tokenFormation = "" + tokenFormation.charAt(0);
                    nova8 = new Token(tokenFormation, estadoAtual, "Abre Parentese");
                    janela.preencherTabela(nova8.getToken(),nova8.getTipo());
                    listaTokens.add(nova8);
                    nova8.imprimeToken();
                }
                estadoAtual = 0;
                tokenFormation = "";
                break;
                
            case 28: //Fecha parêntes
                Token nova9;
                if (tokenFormation.contains(")")) {
                    tokenFormation = "" + tokenFormation.charAt(0);
                    nova9 = new Token(tokenFormation, estadoAtual, "Fecha Parentese");
                    janela.preencherTabela(nova9.getToken(),nova9.getTipo());
                    listaTokens.add(nova9);
                    nova9.imprimeToken();
                }
                estadoAtual = 0;
                tokenFormation = "";
                break;
                
           case 30: //Fecha parêntes
                Token nova10;
                if (tokenFormation.contains(";")) {
                    tokenFormation = "" + tokenFormation.charAt(0);
                    nova10 = new Token(tokenFormation, estadoAtual, "Ponto e Virgula");
                    listaTokens.add(nova10);
                    nova10.imprimeToken();
                }
                estadoAtual = 0;
                tokenFormation = "";
                break;
            
             
            case 59: //operador de multiplicação;
                // i--; // identificador maior;
                Token nova1;
                if (tokenFormation.contains("*")) {
                    tokenFormation = "" + tokenFormation.charAt(0);
                    nova1 = new Token(tokenFormation, estadoAtual, "Operador Multiplicação");
                    janela.preencherTabela(nova1.getToken(),nova1.getTipo());
                    listaTokens.add(nova1);
                    nova1.imprimeToken();
                }
                estadoAtual = 0;
                tokenFormation = "";
                break;
                
            case 61: //Fecha parêntes
                Token nova11;
                nova11 = new Token(tokenFormation, estadoAtual, "Caractere errado");
                janela.preencherTabela(nova11.getToken(),nova11.getTipo());
                listaTokens.add(nova11);
                nova11.imprimeToken();
                estadoAtual = 0;
                tokenFormation = "";
                break;

        }
        for (i = 1; i < linha.length; i++) {


            entrada = (int) linha[i];
            if (i != linha.length - 1) /*if( i != (linha.length - 1)){
             tokenFormation+=linha[i];       // para não pegar o ultimo caractere
             }*/ {
                if (entrada != 32 && entrada != 10) { //evitar concatenar o espaço em branco nos tokens e os enters tmb.
                    tokenFormation += linha[i]; //evitar concatenar /n no token tirar duvida 
                }
            }

            /*      if(linha[i]=='+'){
             if(linha[i-1]=='+'){
             tokenFormation += linha[i];
             }
             }*/

            estadoAnt = estadoAtual;

            if (entrada == 10) {
                estadoAtual = automato[estadoAnt][96];
            } else if (entrada == 9) {
                estadoAtual = automato[estadoAnt][97];
            } else if (entrada == 199) {
                estadoAtual = automato[estadoAnt][95];
            } else {

                estadoAtual = automato[estadoAnt][entrada - 32];
            }

            System.out.print("\nentrada " + linha[i] + " " + "estadoAnterior: " + estadoAnt + " -> " + estadoAtual);

            switch (estadoAtual) {
                case 4:
                    i--;  //Erro no operador diferente (!)
                    Token neweste;
                    if (tokenFormation.contains("!")) {
                        tokenFormation = "" + tokenFormation.charAt(0);
                        neweste = new Token(tokenFormation, estadoAtual, "ERRO NA OPERAÇÃO DIFERENTE");
                        programaSemErro=false;
                        janela.preencherTabela(neweste.getToken(),neweste.getTipo());
                        neweste.imprimeToken();
                    }
                    estadoAtual = 0;
                    tokenFormation = "";
                    break;

                case 6:
                    i--; // Operador subtração

                    Token newest;
                    if (tokenFormation.contains("-")) {
                        tokenFormation = "" + tokenFormation.charAt(0);
                        newest = new Token(tokenFormation, estadoAtual, "OPERADOR SUBTRAÇÃO");
                        janela.preencherTabela(newest.getToken(),newest.getTipo());
                        listaTokens.add(newest);
                        newest.imprimeToken();
                    }
                    estadoAtual = 0;
                    tokenFormation = "";
                    break;
                case 7:
                    i--;   //operador menor
                    Token novaca;

                    if (tokenFormation.contains("<")) {
                        tokenFormation = "" + tokenFormation.charAt(0);
                        novaca = new Token(tokenFormation, estadoAtual, "Operador Menor");
                        janela.preencherTabela(novaca.getToken(),novaca.getTipo());
                        listaTokens.add(novaca);
                        novaca.imprimeToken();
                    }

                    estadoAtual = 0;
                    tokenFormation = "";
                    break;


                case 8: //Operador decremento
                    if (i == (linha.length - 1)) {
                        tokenFormation += linha[i];
                    }
                    Token next = new Token(tokenFormation, estadoAtual, "OPERADOR DECREMENTO");
                    janela.preencherTabela(next.getToken(),next.getTipo());
                    listaTokens.add(next);
                    estadoAtual = 0;
                    next.imprimeToken();
                    tokenFormation = "";
                    break;

                case 9:
                    i--; // operador soma;
                    Token nov;
                    if (tokenFormation.contains("+")) {
                        tokenFormation = "" + tokenFormation.charAt(0);
                        nov = new Token(tokenFormation, estadoAtual, "Operador Soma");
                        janela.preencherTabela(nov.getToken(),nov.getTipo());
                        listaTokens.add(nov);
                        nov.imprimeToken();
                    }
                    estadoAtual = 0;
                    tokenFormation = "";
                    break;
                case 12:  //  erro operador OU
                    i--;
                    tokenFormation = tokenFormation.subSequence(0, tokenFormation.length() - 1).toString();
                    Token tolkiene = new Token(tokenFormation, estadoAtual, "Erro Operador OU");
                    janela.preencherTabela(tolkiene.getToken(),tolkiene.getTipo());
                    listaTokens.add(tolkiene);
                    estadoAtual = 0;
                    tolkiene.imprimeToken();
                    tokenFormation = "";
                    programaSemErro=false;
                    break;
                case 13: // Operador Lógico OU
                    if (i == (linha.length - 1)) {
                        tokenFormation += linha[i];
                    }
                    Token novone = new Token(tokenFormation, estadoAtual, "Operador Lógico OU");
                    janela.preencherTabela(novone.getToken(),novone.getTipo());
                    listaTokens.add(novone);
                    estadoAtual = 0;
                    novone.imprimeToken();
                    tokenFormation = "";
                    break;
                case 14:  //  erro operador AND
                    i--;
                    //tokenFormation = tokenFormation.subSequence(0, tokenFormation.length() - 1).toString();
                    Token tol = new Token(tokenFormation, estadoAtual, "Erro Operador AND");
                    janela.preencherTabela(tol.getToken(),tol.getTipo());
                    listaTokens.add(tol);
                    estadoAtual = 0;
                    tol.imprimeToken();
                    tokenFormation = "";
                    programaSemErro=false;
                    break;

                case 16: //COMENTARIO DE LINHA
                    if (i == (linha.length - 1)) {
                        tokenFormation += linha[i];
                    }
                    Token nextTolkien = new Token(tokenFormation, estadoAtual, "COMENTARIO DE LINHA");
                    janela.preencherTabela(nextTolkien.getToken(),nextTolkien.getTipo());
                    estadoAtual = 0;
                    nextTolkien.imprimeToken();
                    tokenFormation = "";
                    break;

                case 17:
                    i--;   // operador Igual
                    Token igual;
                    if (tokenFormation.contains("/")) {
                        tokenFormation = "" + tokenFormation.charAt(0);
                        igual = new Token(tokenFormation, estadoAtual, "OPERADOR DE DIVISÃO");
                        janela.preencherTabela(igual.getToken(),igual.getTipo());
                        listaTokens.add(igual);
                        igual.imprimeToken();
                    }
                    estadoAtual = 0;
                    tokenFormation = "";
                    break;
                    
                 case 20://Erro de EOF
                    if (i == (linha.length - 1)) {
                        tokenFormation += linha[i];
                    }
                    Token next2Tolkien = new Token(tokenFormation, estadoAtual, "ERRO DE FIM DE ARQUIVO");
                    janela.preencherTabela(next2Tolkien.getToken(),next2Tolkien.getTipo());
                    estadoAtual = 0;
                    next2Tolkien.imprimeToken();
                    tokenFormation = "";
                    programaSemErro=false;
                    break;

                case 21:
                    if (i == (linha.length - 1)) {
                        tokenFormation += linha[i];
                    }
                    Token next1Tolkien = new Token(tokenFormation, estadoAtual, "COMENTARIO DE BLOCO");
                    janela.preencherTabela(next1Tolkien.getToken(),next1Tolkien.getTipo());
                    estadoAtual = 0;
                    next1Tolkien.imprimeToken();
                    tokenFormation = "";
                    break;

                case 22: //operador de PONTO;

                    Token nova2;
                    tokenFormation += linha[i];
                    //System.out.println("Entrou no case");
                    if (tokenFormation.contains(".")) {
                        tokenFormation = "" + tokenFormation.charAt(0);
                        nova2 = new Token(tokenFormation, estadoAtual, "Operador Ponto");
                        janela.preencherTabela(nova2.getToken(),nova2.getTipo());
                        listaTokens.add(nova2);
                        nova2.imprimeToken();
                    }
                    estadoAtual = 0;
                    tokenFormation = "";
                    break;
                case 23: //operador de Abre Chaves;

                    Token nova3;
                    tokenFormation += linha[i];
                    //System.out.println("Entrou no case");
                    if (tokenFormation.contains("{")) {
                        tokenFormation = "" + tokenFormation.charAt(0);
                        nova3 = new Token(tokenFormation, estadoAtual, "Abre Chaves");
                        janela.preencherTabela(nova3.getToken(),nova3.getTipo());
                        listaTokens.add(nova3);
                        nova3.imprimeToken();
                    }
                    estadoAtual = 0;
                    tokenFormation = "";
                    break;
                   
               case 24: //operador de fecha Chaves;
                    
                    Token nova4;
                    tokenFormation += linha[i];
                    //System.out.println("Entrou no case");
                    if (tokenFormation.contains("}")) {
                        tokenFormation = "" + tokenFormation.charAt(0); 
                        nova4 = new Token(tokenFormation, estadoAtual, "Fecha Chaves");
                        janela.preencherTabela(nova4.getToken(),nova4.getTipo());
                        listaTokens.add(nova4);
                        nova4.imprimeToken();
                    }
                    estadoAtual = 0;
                    tokenFormation = "";
                    break;
                   
               case 25: //Abre Colchete;
                    
                    Token nova5;
                    tokenFormation += linha[i];
                    //System.out.println("Abre Colchete");
                    if (tokenFormation.contains("[")) {
                        tokenFormation = "" + tokenFormation.charAt(0);
                        nova5 = new Token(tokenFormation, estadoAtual, "Abre Colchetes");
                        janela.preencherTabela(nova5.getToken(),nova5.getTipo());
                        listaTokens.add(nova5);
                        nova5.imprimeToken();
                    }
                    estadoAtual = 0;
                    tokenFormation = "";
                    break;
                   
               case 26: //Fecha Colchete;
                    
                    Token nova6;
                    tokenFormation += linha[i];
                    if (tokenFormation.contains("]")) {
                        tokenFormation = "" + tokenFormation.charAt(0);
                        nova6 = new Token(tokenFormation, estadoAtual, "Fecha Colchete");
                        janela.preencherTabela(nova6.getToken(),nova6.getTipo());
                        listaTokens.add(nova6);
                        nova6.imprimeToken();
                    }
                    estadoAtual = 0;
                    tokenFormation = "";
                    break;
                   
               case 27: //Abre Parentese;
                    
                    Token nova7;
                    tokenFormation += linha[i];
                    if (tokenFormation.contains("(")) {
                        tokenFormation = "" + tokenFormation.charAt(0);
                        nova7 = new Token(tokenFormation, estadoAtual, "Abre Parentese");
                        janela.preencherTabela(nova7.getToken(),nova7.getTipo());
                        listaTokens.add(nova7);
                        nova7.imprimeToken();
                    }
                    estadoAtual = 0;
                    tokenFormation = "";
                    break;
          case 28: //Fecha Parentese;
                     Token nova8;
                    tokenFormation += linha[i];
                    if (tokenFormation.contains(")")) {
                        tokenFormation = "" + tokenFormation.charAt(0);
                        nova8 = new Token(tokenFormation, estadoAtual, "Fecha Parentese");
                        janela.preencherTabela(nova8.getToken(),nova8.getTipo());
                        listaTokens.add(nova8);
                        nova8.imprimeToken();
                    }
                    estadoAtual = 0;
                    tokenFormation = "";
                    break;
                   
               case 30: //Ponto e Vírgula;
                    
                    Token nova9;
                    tokenFormation += linha[i];
                    if (tokenFormation.contains(";")) {
                        tokenFormation = "" + tokenFormation.charAt(0);
                        nova9 = new Token(tokenFormation, estadoAtual, "Ponto e Vírgula");
                        janela.preencherTabela(nova9.getToken(),nova9.getTipo());
                        listaTokens.add(nova9);
                        nova9.imprimeToken();
                    }
                    estadoAtual = 0;
                    tokenFormation = "";
                    break;

                case 29: //Delimitador virgula.
                    Token nova10;
                    tokenFormation += linha[i];
                    //System.out.println("Entrou no case");
                    if (tokenFormation.contains(",")) {
                        tokenFormation = "" + tokenFormation.charAt(0);
                        nova10 = new Token(tokenFormation, estadoAtual, "DELIMITADOR VIRGULA");
                        janela.preencherTabela(nova10.getToken(),nova10.getTipo());
                        listaTokens.add(nova10);
                        nova10.imprimeToken();
                    }
                        estadoAtual=0;
                        tokenFormation="";
                   break;
                    
                case 32:
                    i--; //Numero devidamente reconhecido
                    if (tokenFormation.charAt(tokenFormation.length() - 1) == '<' || tokenFormation.charAt(tokenFormation.length() - 1) == '>'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == '=' || tokenFormation.charAt(tokenFormation.length() - 1) == '+'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == '*' || tokenFormation.charAt(tokenFormation.length() - 1) == '-'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == '/' || tokenFormation.charAt(tokenFormation.length() - 1) == '.'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == '[' || tokenFormation.charAt(tokenFormation.length() - 1) == ']'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == '{' || tokenFormation.charAt(tokenFormation.length() - 1) == '}'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == '(' || tokenFormation.charAt(tokenFormation.length() - 1) == ')'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == ';' || tokenFormation.charAt(tokenFormation.length() - 1) == ',') { //evitar salvar operador ou delimitador junto ao toke identificador.

                        tokenFormation = tokenFormation.subSequence(0, tokenFormation.length() - 1).toString(); //tentativa para não pegar o ultimo caracter
                    }
                    Token tolken = new Token(tokenFormation, estadoAtual, "Numero Inteiro");
                    janela.preencherTabela(tolken.getToken(),tolken.getTipo());
                    listaTokens.add(tolken);
                    estadoAtual = 0;
                    tolken.imprimeToken();
                    tokenFormation = "";
                    break;

                case 34: //erro de número mal formado
                    i--;
                    Token tollkien = new Token(tokenFormation, estadoAtual, "Numero mal formado");
                    janela.preencherTabela(tollkien.getToken(),tollkien.getTipo());
                    estadoAtual = 0;
                    tollkien.imprimeToken();
                    tokenFormation = "";
                    programaSemErro=false;
                    break;
                case 36: //numero float aceito
                    i--;
                    tokenFormation = tokenFormation.subSequence(0, tokenFormation.length() - 1).toString();
                    Token tolkien = new Token(tokenFormation, estadoAtual, "Numero decimal");
                    janela.preencherTabela(tolkien.getToken(),tolkien.getTipo());
                    listaTokens.add(tolkien);
                    estadoAtual = 0;
                    tolkien.imprimeToken();
                    tokenFormation = "";
                    break;
                case 38: //Erro fim de arquivo em comentario de bloco
                    if (i == (linha.length - 1)) {
                        tokenFormation += linha[i];
                    }
                    Token next3Tolkien = new Token(tokenFormation, estadoAtual, "ERRO DE FIM DE ARQUIVO");
                    janela.preencherTabela(next3Tolkien.getToken(),next3Tolkien.getTipo());
                    estadoAtual = 0;
                    next3Tolkien.imprimeToken();
                    tokenFormation = "";
                    programaSemErro=false;
                    break;

                case 39: Token token;
                    i--; //Identificador bem formado;
                    if (tokenFormation.charAt(tokenFormation.length() - 1) == '<' || tokenFormation.charAt(tokenFormation.length() - 1) == '>'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == '=' || tokenFormation.charAt(tokenFormation.length() - 1) == '+'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == '*' || tokenFormation.charAt(tokenFormation.length() - 1) == '-'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == '/' || tokenFormation.charAt(tokenFormation.length() - 1) == '.'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == '[' || tokenFormation.charAt(tokenFormation.length() - 1) == ']'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == '{' || tokenFormation.charAt(tokenFormation.length() - 1) == '}'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == '(' || tokenFormation.charAt(tokenFormation.length() - 1) == ')'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == ';' || tokenFormation.charAt(tokenFormation.length() - 1) == ',') { //evitar salvar operador ou delimitador junto ao toke identificador.

                        tokenFormation = tokenFormation.subSequence(0, tokenFormation.length() - 1).toString(); //tentativa para não pegar o ultimo caracter
                    }
                     if(palavrasReservadas.contains(tokenFormation)){
                      token = new Token(tokenFormation, estadoAtual, "Palavra Reservada");
                     }
                     else{
                      token = new Token(tokenFormation, estadoAtual, "Identificador");    
                     }
                    
                    janela.preencherTabela(token.getToken(),token.getTipo());
                    listaTokens.add(token);
                    estadoAtual = 0;
                    token.imprimeToken();
                    tokenFormation = "";
                    break;
                case 40:
                    i--; //Identificador mal formado;
                    if (tokenFormation.charAt(tokenFormation.length() - 1) == '<' || tokenFormation.charAt(tokenFormation.length() - 1) == '>'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == '=' || tokenFormation.charAt(tokenFormation.length() - 1) == '+'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == '*' || tokenFormation.charAt(tokenFormation.length() - 1) == '-'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == '/' || tokenFormation.charAt(tokenFormation.length() - 1) == '.'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == '[' || tokenFormation.charAt(tokenFormation.length() - 1) == ']'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == '{' || tokenFormation.charAt(tokenFormation.length() - 1) == '}'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == '(' || tokenFormation.charAt(tokenFormation.length() - 1) == ')'
                            || tokenFormation.charAt(tokenFormation.length() - 1) == ';' || tokenFormation.charAt(tokenFormation.length() - 1) == ',') { //evitar salvar operador ou delimitador junto ao toke identificador.

                        tokenFormation = tokenFormation.subSequence(0, tokenFormation.length() - 1).toString(); //tentativa para não pegar o ultimo caracter
                    }
                    Token tok = new Token(tokenFormation, estadoAtual, "Identificador mal formado");
                    janela.preencherTabela(tok.getToken(),tok.getTipo());
                    estadoAtual = 0;
                    tok.imprimeToken();
                    tokenFormation = "";
                    programaSemErro=false;
                    break;
                case 42://i--;
                    tokenFormation += linha[i];
                    Token newTok = new Token(tokenFormation, estadoAtual, "Erro Cadeia Mal Formada");
                    janela.preencherTabela(newTok.getToken(),newTok.getTipo());
                    estadoAtual = 0;
                    newTok.imprimeToken();
                    tokenFormation = "";
                    programaSemErro=false;
                    break;

                case 43: //String Reconhecida
                   // tokenFormation += linha[i];
                    tokenFormation.subSequence(0, tokenFormation.length() - 1).toString();
                    Token newToken = new Token(tokenFormation, estadoAtual, "String");
                    janela.preencherTabela(newToken.getToken(),newToken.getTipo());
                    listaTokens.add(newToken);
                    estadoAtual = 0;
                    newToken.imprimeToken();
                    tokenFormation = "";
                    break;

                case 46: //i--; //erro caractere
                    Token touken;
                    tokenFormation += linha[i];
                    if (tokenFormation.contains("Ç")) {
                        touken = new Token(tokenFormation, estadoAtual, "ERRO CARACTERE EOF");
                        janela.preencherTabela(touken.getToken(),touken.getTipo());
                        touken.imprimeToken();
                    } else {
                        touken = new Token(tokenFormation, estadoAtual, "ERRO CARACTERE MAL FORMADO");
                        janela.preencherTabela(touken.getToken(),touken.getTipo());
                        touken.imprimeToken();
                    }
                    estadoAtual = 0;
                    tokenFormation = "";
                    programaSemErro=false;
                    break;

                case 47: //i--; //erro caractere 2
                    Token touk;
                    touk = new Token(tokenFormation, estadoAtual, "ERRO CARACTERE MAL FORMADO");
                    janela.preencherTabela(touk.getToken(),touk.getTipo());
                    touk.imprimeToken();
                    estadoAtual = 0;
                    tokenFormation = "";
                    programaSemErro=false;
                    break;



                case 48: //i--; //caractere bem formado

                    Token taken;

                    if (i == (linha.length - 1)) {
                        tokenFormation += linha[i];
                    }

                    //tokenFormation += linha[i];
                    if (i == (linha.length - 1)) {
                        tokenFormation += linha[i];
                    }

                    taken = new Token(tokenFormation, estadoAtual, "CARACTERE BEM FORMADO");
                    janela.preencherTabela(taken.getToken(),taken.getTipo());
                    listaTokens.add(taken);
                    taken.imprimeToken();
                    estadoAtual = 0;
                    tokenFormation = "";
                    break;




                case 49:  //Operador diferente igual
                    if (i == (linha.length - 1)) {
                        tokenFormation += linha[i];
                    }
                    Token novobe = new Token(tokenFormation, estadoAtual, "Operador Diferente Igual");
                    janela.preencherTabela(novobe.getToken(),novobe.getTipo());
                    listaTokens.add(novobe);
                    estadoAtual = 0;
                    novobe.imprimeToken();
                    tokenFormation = "";
                    break;

                case 51: // operador Igual Igual
                    if (i == (linha.length - 1)) {
                        tokenFormation += linha[i];
                    }
                    Token novon = new Token(tokenFormation, estadoAtual, "Operador Igual Igual");
                    janela.preencherTabela(novon.getToken(),novon.getTipo());
                    listaTokens.add(novon);
                    estadoAtual = 0;
                    novon.imprimeToken();
                    tokenFormation = "";
                    break;
                case 52:
                    i--;   // operador Igual
                    Token novinha;
                    if (tokenFormation.contains("=")) {
                        tokenFormation = "" + tokenFormation.charAt(0);
                        novinha = new Token(tokenFormation, estadoAtual, "Operador Igual");
                        janela.preencherTabela(novinha.getToken(),novinha.getTipo());
                        listaTokens.add(novinha);
                        novinha.imprimeToken();
                    }
                    estadoAtual = 0;
                    tokenFormation = "";
                    break;


                case 54: //i--; //identificador maior igual;
                    if (i == (linha.length - 1)) {
                        tokenFormation += linha[i];
                    }
                    Token novo = new Token(tokenFormation, estadoAtual, "Operador Maior Igual");
                    janela.preencherTabela(novo.getToken(),novo.getTipo());
                    listaTokens.add(novo);
                    estadoAtual = 0;
                    novo.imprimeToken();
                    tokenFormation = "";
                    break;
                case 55:
                    i--; // identificador maior;
                    Token nova;
                    if (tokenFormation.contains(">")) {
                        tokenFormation = "" + tokenFormation.charAt(0);
                        nova = new Token(tokenFormation, estadoAtual, "Operador Maior");
                        janela.preencherTabela(nova.getToken(),nova.getTipo());
                        listaTokens.add(nova);
                        nova.imprimeToken();
                    }
                    estadoAtual = 0;
                    tokenFormation = "";
                    break;

                case 56: // Operador <=
                    if (i == (linha.length - 1)) {
                        tokenFormation += linha[i];
                    }
                    Token novob = new Token(tokenFormation, estadoAtual, "Operador Menor Igual");
                    janela.preencherTabela(novob.getToken(),novob.getTipo());
                    listaTokens.add(novob);
                    estadoAtual = 0;
                    novob.imprimeToken();
                    tokenFormation = "";
                    break;

                case 57:  // operador ++
                    Token newto;

                    if (i == (linha.length - 1)) {
                        tokenFormation += linha[i];
                    }

                    //tokenFormation += linha[i];
                    newto = new Token(tokenFormation, estadoAtual, "Operador Incremento");
                    janela.preencherTabela(newto.getToken(),newto.getTipo());
                    listaTokens.add(newto);
                    newto.imprimeToken();

                    estadoAtual = 0;
                    tokenFormation = "";
                    break;


                case 58: //operador &&
                    Token newton;

                    if (i == (linha.length - 1)) {
                        tokenFormation += linha[i];
                    }

                    //tokenFormation += linha[i];
                    newton = new Token(tokenFormation, estadoAtual, "OPERADOR LOGICO AND");
                    janela.preencherTabela(newton.getToken(),newton.getTipo());
                    listaTokens.add(newton);
                    newton.imprimeToken();
                    estadoAtual = 0;
                    tokenFormation = "";
                    break;

                case 59: //operador de multiplicação;
                    // i--; // identificador maior;
                    Token nova1;
                    tokenFormation += linha[i];
                    if (tokenFormation.contains("*")) {
                        tokenFormation = "" + tokenFormation.charAt(0);

                        nova1 = new Token(tokenFormation, estadoAtual, "OPERADOR MULTIPLICAÇÃO");
                        janela.preencherTabela(nova1.getToken(),nova1.getTipo());
                        listaTokens.add(nova1);

                        //    nova1 = new Token(tokenFormation, estadoAtual, "Operador Multiplicação");

                        nova1.imprimeToken();
                    }
                    estadoAtual = 0;
                    tokenFormation = "";
                    break;
                    
               case 61: //Caractere Errado;
                    
                   Token nova11;
                   if (i == (linha.length - 1)) {
                       tokenFormation += linha[i];
                   }
                   nova9 = new Token(tokenFormation, estadoAtual, "Caractere Errado");
                   janela.preencherTabela(nova9.getToken(),nova9.getTipo());
                   nova9.imprimeToken();
                   estadoAtual = 0;
                   tokenFormation = "";
                   programaSemErro=false;
                   break;
            }

        }
        return programaSemErro;
      
    }
    public List getTokenList(){
    return listaTokens;
    }

    public void inicializarAutomato() {

        for (int i = 0; i < dadosArquivo.size(); i++) {
            System.out.printf("Linha:" + i);
            for (int j = 0; j < dadosArquivo.get(i).length; j++) {
                automato[i][j] = dadosArquivo.get(i)[j];
                System.out.print(" " + automato[i][j]);
            }
            System.out.println("");
        }
    }

    public void imprimeAutomato() {
        System.out.println("\nTabela automato\n");
        for (int i = 0; i < 66; i++) {
            System.out.printf("Linha:" + i + " ");
            for (int j = 0; j < 130; j++) {

                System.out.printf(" " + automato[i][j]);
            }
            System.out.println("");
        }



    }

    /* public void leArquivo(String arquivo) {  
     try {  
     BufferedReader in = new BufferedReader(new FileReader(arquivo));  
     String str;  
     // int i = 0, j=0;
     while ((str = in.readLine()) != null){  
    
    
     System.out.println(str);  
     }  
     } catch (Exception e) {  
     e.printStackTrace();  
     }*/
    public void imprimeListaToken(){
    
    for(int i=0; i<listaTokens.size();i++){
    
        System.out.println(""+listaTokens.get(i).getToken()+"\n");
    }
    
    }
    public ArrayList<int[]> leArquivo_a(String path) throws Exception {

        ArrayList<int[]> dadosArquivo = new ArrayList<int[]>();

        BufferedReader reader = new BufferedReader(new InputStreamReader(
                new FileInputStream(path)));

        String[] line = null;
        String temp;
        while ((temp = reader.readLine()) != null) {
            line = temp.split(";");
            int[] lineInt = new int[line.length - 1];
            for (int i = 1; i < line.length; i++) {
                lineInt[i - 1] = Integer.parseInt(line[i]);
            }
            dadosArquivo.add(lineInt);
        }
        this.dadosArquivo = dadosArquivo;

        return dadosArquivo;
    }

    public void imprimeAutomatoArq() {

        for (int i = 0; i < dadosArquivo.size(); i++) {
            System.out.printf("Linha:" + i);
            for (int j = 0; j < dadosArquivo.get(i).length; j++) {
                System.out.print(" " + dadosArquivo.get(i)[j]);
            }
            System.out.println("");

        }



    }
}
